/**
 * 用户管理模块（适用于AI对话系统等网页用户管理）
 */

const router = require('koa-router')()
const User = require('./../models/userSchema')
const Counter = require('./../models/counterSchema')
const Menu = require('./../models/menuSchema')
const Role = require('./../models/roleSchema')
const UserLogin = require('./../models/userLoginSchema')
const util = require('./../utils/util')
const jwt = require('jsonwebtoken')
const md5 = require('md5')

router.prefix('/users')


//用户登录
router.post('/login',async (ctx)=>{
  try {
    const { userName, userPwd } = ctx.request.body;
    const res = await User.findOne({
      userName,
      userPwd: md5(userPwd)
    }, 'userId userName userEmail state role roleList lastLoginTime')

    if(res && res._doc.state != 2){
      // 账号密码正确，且没有被禁用
      const data = res._doc;
      const token = jwt.sign({
        data
      },'zufe', { expiresIn: '5h' })

      data.token = token;
      //修改登录时间
      await User.updateOne(
        { userId: data.userId },
        { $set: { lastLoginTime: new Date() } }
      );
      // 记录登录日志
      const userLogin = new UserLogin({
        userId: data.userId,
        userName: data.userName,
        lastLoginTime: new Date()
      })
      userLogin.save();
      ctx.body = util.success(data)
    }else if(res && res._doc.state == 2){
      // 账号被禁用
      ctx.body = util.fail("用户已被禁用")
    }
    else{
      ctx.body = util.fail("账号或密码不正确")
    }
  } catch (error) {
    ctx.body = util.fail(error.msg)
  }
  
})

// 用户列表
router.get('/list', async (ctx) => {
  // 解构前端传递的查询参数
  const { userId, userName, state } = ctx.request.query;
  // 解构分页参数
  const { page, skipIndex } = util.pager(ctx.request.query);
  // 定义查询条件
  let params = {}
  // 如果有传递参数，则添加到查询条件中
  if(userId) params.userId = userId;
  if(userName) params.userName = userName;
  if(state && state != '0') params.state = state;
  try {
    // 根据条件查询所有用户列表
    const query = User.find(params, { _id: 0, userPwd: 0 })
    // 将查询到的结果进行分页处理
    const list = await query.skip(skipIndex).limit(page.pageSize)
    // 统计符合条件的总记录数
    const total = await User.countDocuments(params)

    ctx.body = util.success({
      page:{
        ...page,
        total
      },
      list
    })

  } catch (error) {
    ctx.body = util.fail(`查询异常:${error.stack}`)
  }
})

// 用户删除/批量删除
router.post('/delete', async (ctx) => {
  // 待删除的用户id数组
  const { userIds } = ctx.request.body;
  // 将用户状态改为2（禁用）
  const res = await User.updateMany({ userId: { $in: userIds } }, { state: 2 })
  // 如果操作成功，则返回成功信息
  if(res.modifiedCount){
    ctx.body = util.success(res, `共操作成功${res.modifiedCount}条数据`)
    return;
  }
  ctx.body = util.fail('操作失败');
})

// 更新单个用户状态（启用/禁用）
router.post('/updateState', async (ctx) => {
  const { userId, state } = ctx.request.body;
  
  if (!userId || state === undefined) {
    ctx.body = util.fail('参数错误，缺少userId或state', util.CODE.PARAM_ERROR);
    return;
  }
  
  try {
    const res = await User.updateOne(
      { userId },
      { state }
    );
    
    if (res.modifiedCount) {
      ctx.body = util.success(res, `用户${state === 2 ? '禁用' : '启用'}成功`);
    } else {
      ctx.body = util.fail(`用户${state === 2 ? '禁用' : '启用'}失败`);
    }
  } catch (error) {
    ctx.body = util.fail(`操作异常：${error.stack}`);
  }
})

// 批量更新用户状态（启用/禁用）
router.post('/batchUpdateState', async (ctx) => {
  const { userIds, state } = ctx.request.body;
  
  if (!userIds || userIds.length === 0 || state === undefined) {
    ctx.body = util.fail('参数错误，缺少userIds或state', util.CODE.PARAM_ERROR);
    return;
  }
  
  try {
    const res = await User.updateMany(
      { userId: { $in: userIds } },
      { state }
    );
    
    if (res.modifiedCount) {
      ctx.body = util.success(res, `共${state === 2 ? '禁用' : '启用'}成功${res.modifiedCount}条数据`);
    } else {
      ctx.body = util.fail(`批量${state === 2 ? '禁用' : '启用'}失败`);
    }
  } catch (error) {
    ctx.body = util.fail(`操作异常：${error.stack}`);
  }
})


// 用户密码重置
router.post('/pwdReset', async (ctx) => {
  // 待重置的用户id数组
  const { userIds } = ctx.request.body;

  // 根据条件重置密码
  const res = await User.updateMany({ userId: { $in: userIds } }, { userPwd: md5('123456') })
  // 如果重置成功，则返回成功信息
  if(res.modifiedCount){
    ctx.body = util.success(res, '密码重置成功')
    return;
  }
  ctx.body = util.fail('密码重置失败');
})


// 用户新增/编辑
router.post('/operate', async (ctx) => {
  // 解构前端传递的参数，取出需要的参数（已移除deptId）
  const { userId, userName, userEmail, state, roleList, mobile, action } = ctx.request.body;
  // 如果是新增，则需要必须包含用户名称、邮箱
  if (action == 'add') {
    if(!userName || !userEmail) {
      ctx.body = util.fail('参数错误', util.CODE.PARAM_ERROR)
      return;
    }
    // 根据新增的用户名和邮箱查询数据库，判断是否已存在
    const res = await User.findOne({$or:[{userName}, {userEmail}]}, '_id userName userEmail')
    if (res) {
      ctx.body = util.fail('用户名或邮箱已存在', util.CODE.PARAM_ERROR)
      return;
    } else {
      // 获取当前用户id
      const doc = await Counter.findOneAndUpdate({ _id: 'userId' }, { $inc: { sequence_value: 1 } }, { new: true })
      try {
        // 创建新的用户对象
        const user = new User({
          userId: doc.sequence_value,
          userName,
          userPwd: md5('123456'),//默认密码
          userEmail,
          role: 1,//默认普通用户
          state,
          roleList,
          mobile
        })
        user.save();
        ctx.body = util.success('', '用户创建成功');
      } catch (error) {
        ctx.body = util.fail(error.stack, '用户创建失败');
      }
    }
  } else {
    try {
      // 如果是编辑，更新用户信息（已移除deptId）
      const res = await User.findOneAndUpdate({ userId }, { state, roleList, mobile })
      ctx.body = util.success({}, '更新成功')
    } catch (error) {
      ctx.body = util.fail(error.stack, '更新失败')
    }
  }
})

// 获取当前用户信息接口
router.get('/current', async (ctx) => {
  // 获取请求头中的token
  const token = ctx.headers.authorization && ctx.headers.authorization.replace('Bearer ', '');
  // 如果没有token，则返回错误信息
  if (!token) {
    ctx.body = util.fail('缺少Token');
    return;
  }
  try {
    // 验证token的合法性
    const decoded = jwt.verify(token, 'zufe');
    // 获取token中的用户id
    const userId = decoded.data.userId;
    // 根据用户id查询数据库，获取用户信息
    const user = await User.findOne({ userId }, { _id: 0 });
    // 如果查询到用户信息，则返回用户信息
    if (user) {
        ctx.body = util.success(user);
    } else {
        ctx.body = util.fail('未找到当前用户信息');
      }
  } catch (error) {
    ctx.body = util.fail('Token验证失败，请重新登录');
  }
})

// 更新当前用户信息接口
router.post('/updateCurrent', async (ctx) => {
  // 获取请求头中的token
  const token = ctx.headers.authorization && ctx.headers.authorization.replace('Bearer ', '');
  if (!token) {
    ctx.body = util.fail('缺少Token');
    return;
  }
  try {
    // 验证token的合法性
    const decoded = jwt.verify(token, 'zufe');
    // 获取token中的用户id
    const userId = decoded.data.userId;
    const { job, mobile } = ctx.request.body;
    const updatedUser = await User.findOneAndUpdate(
        { userId },
        { job, mobile },
        { new: true }
    );
    if (updatedUser) {
        ctx.body = util.success(updatedUser, '更新成功');
    } else {
        ctx.body = util.fail('更新失败');
    }
  } catch (error) {
    ctx.body = util.fail('Token验证失败，请重新登录');
  }
})

// 修改密码路由
router.post('/changePassword', async (ctx) => {
  const { oldPassword, newPassword } = ctx.request.body;
  const token = ctx.headers.authorization && ctx.headers.authorization.replace('Bearer ', '');
  if (!token) {
      ctx.body = util.fail('缺少Token');
      return;
  }
  try {
      const decoded = jwt.verify(token, 'zufe');
      const userId = decoded.data.userId;
      const user = await User.findOne({ userId });
      if (user.userPwd!== md5(oldPassword)) {
          ctx.body = util.fail('原密码错误');
          return;
      }
      const updatedUser = await User.findOneAndUpdate(
          { userId },
          { userPwd: md5(newPassword) },
          { new: true }
      );
      if (updatedUser) {
          ctx.body = util.success(updatedUser, '密码修改成功');
      } else {
          ctx.body = util.fail('密码修改失败');
      }
  } catch (error) {
      ctx.body = util.fail('Token验证失败，请重新登录');
  }
})

// 获取全量用户列表
router.get('/all/list', async (ctx) => { 
  try {
    const list = await User.find({}, "userId userName userEmail")
    ctx.body = util.success(list)
  } catch (error) {
    ctx.body = util.fail(error.stack)
  }
})

// 获取用户对应的权限菜单
router.get("/getPermissionList", async (ctx) => {
  // 获取请求头中的token
  let authorization = ctx.request.headers.authorization
  let { data } = util.decoded(authorization)
  let menuList = await getMenuList(data.role, data.roleList)
  // 深拷贝一份数据
  let actionList = getActionList(JSON.parse(JSON.stringify(menuList)))
  ctx.body = util.success({menuList, actionList})
})

async function getMenuList(userRole, roleKeys) {
  let rootList = []
  if (userRole == 0) {
    rootList = await Menu.find({}) || []
  } else {
    // 根据用户拥有的角色获取权限列表
    let roleList = await Role.find({ _id: { $in: roleKeys } })
    let permissionList = []
    roleList.map(role => {
      let { checkedKeys, halfCheckedKeys } = role.permissionList
      permissionList = permissionList.concat([...checkedKeys, ...halfCheckedKeys])
    })
    // 去重
    permissionList = [...new Set(permissionList)]
    rootList = await Menu.find({ _id: { $in: permissionList } })
  }
  return util.getTreeMenu(rootList, null, [])
}

function getActionList(list) {
  const actionList = []
  const deep = (arr) => {
    while (arr.length) {
      let item = arr.pop()
      if (item.action) {
        item.action.map(action => {
          actionList.push(action.menuCode)
        })
      }
      if (item.children && !item.action) {
          deep(item.children)
      }
    }
  }
  deep(list)
  return actionList
}

module.exports = router
